#include "logo.h"

//ejemplo para inicializar: Cfuente arcade8(8,"arcadeclassic.ttf")
CLogo::CLogo (char inombre[128])
{
  visible = true;
   logo = IMG_Load(inombre);                         // carga la imagen del logotipo.
     if (!logo) printf ("Logo::Clogo::Error al cargar logotipo:%s\n",inombre);
  SDL_SetAlpha(logo, 0, 0);                        // arregla el problema con el alpha (!) 
   
  tancho=logo->w;  // resetea estas variables
  talto =logo->h;  // si no son mayores de 512 dejara estos valores.
  ancho=logo->w;   // halla las dimensiones totales de la imagen
  alto =logo->h;
  th=1;
  tv=1;
  
  if (logo->w>512) { tancho=logo->w/2;th=2; }                // si es mayor de 512
  if (tancho>512)  { tancho=logo->w/3;th=3; }                      // si es mayor de 1024
  if (logo->w>512) { talto=logo->h/2;tv=2; }                // si es mayor de 512
  if (talto>512)   { talto=logo->h/3;tv=3; }                      // si es mayor de 1024
  
  /*if (logo->w>512) th=logo->w/512; // cuantos bloques horizontales  
   else th=1;
  if (logo->h>512) tv=logo->h/512; // cuantos cuantos verticales
   else tv=1; */
  ntextura= th*tv;                  // numero de texturas 
  text_array =new GLuint[ntextura];                 // crea el array de texturas 
  /* definimos la superficie de la textura */
  
  
 
 
  
   
}


void CLogo::creat()
{
  textura=Crea_Imagen_Alpha1 ( tancho, talto );
   SDL_FillRect(textura, NULL, 0x00000000);     
  SDL_Rect text_rect = {0,0,tancho,talto};
  SDL_Rect bloq_rect ={0,0,tancho,talto};
  int control,posh,posv;                                                         // variables para los saltos de testura 
  for (int i=0;i<ntextura;i++)
  {
   /**************************************************************************/   
   /* Esta rutina calcula la posicion de cada tile dentro de la imagen de los tiles */
   /**************************************************************************/
    control = (ancho/tancho);               // halla el numero de tiles en un linea
    if (i>=control) posv=i / control;         // halla la posicion vertical,
      else posv=0;
    if (i>=control) posh  = i-control*posv;   // halla la posicion horizontal.
      else posh = i;
   /*************************************************************************/
     
    bloq_rect.x=posh*tancho;
    bloq_rect.y=posv*talto;
    SDL_BlitSurface(logo, &bloq_rect, textura, &text_rect);       
    glGenTextures (1, &textid);  // Genera la textura  
    glBindTexture (GL_TEXTURE_2D , textid);
    glTexImage2D (GL_TEXTURE_2D, 0 ,4,tancho,talto,0, GL_RGBA,
    GL_UNSIGNED_BYTE, textura->pixels ); // traslada la textura a GL
    text_array[i]=textid; // guarda el id en el array
   
   }
   
   SDL_FreeSurface(logo);
  SDL_FreeSurface(textura); 
 printf ("Logo::Creat::Numero de Texturas:%i\n",ntextura);
 printf ("Logo::Creat::Ancho y Alto:%i , %i\n",tancho,talto);
 printf ("Logo::Creat::bloques horizontales:%i , bloques verticales:%i\n",th,tv);  
}
      
      
      
void CLogo::pinta ()
{
 /* activar en caso de debug */

  int nancho=(tancho/2);    // nuevo
  int nalto= (talto/2);    // nuevo
  int Ix;// = int (x)+nancho; // nuevo
  int Iy;// = int (y)+nalto;  // nuevo 
  int control,posh,posv; 
  float escalon; 

  
 for (int i=0;i<ntextura;i++)
 {  /* inicia el bucle */
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   /**************************************************************************/   
   /* Esta rutina calcula la posicion de cada tile dentro de la imagen de los tiles */
   /**************************************************************************/
     control = (ancho/tancho);               // halla el numero de tiles en un linea
    if (i>=control) posv=i / control;         // halla la posicion vertical,
      else posv=0;
    if (i>=control) posh  = i-control*posv;   // halla la posicion horizontal.
      else posh = i;
   /*************************************************************************/
 //escalon =((1.0-escala)*1000)*escala;
  
  Ix=int (x)+nancho+(posh*tancho);  //-(int(escalon)*posh);
  Iy=int (y)+nalto+(posv*talto);
 
  
 
  
  glEnable(GL_TEXTURE_2D);
  //glBindTexture(GL_TEXTURE_2D,textid);
  glBindTexture(GL_TEXTURE_2D,text_array[i]); // asigna el identificador de textura
 
   if (filtro==1){
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR );
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR );}
  if (filtro==0){
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST );       // SIN FILTRO
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);  }     // SIN FILTRO
  if (filtro==2){
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_REPEAT); }  
 
  if (alfa)
  {
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // a ver
  } 
  glTranslatef ( Ix, Iy, 0 );                                                   // Mueve el objeto
  glScalef (escala,escala,escala);                                              // produce el escalado
  //glRotated (rotacionZ,0,0,1);                                                  // rota sobre el eje z
  //glRotated (100,0,0,1);
  
  
  glBegin (GL_QUADS);                                                         // Usamos el objeto Quads
    
    glTexCoord2d (1.0 , 0.0);
    //glTexCoord2d (0.0 , 0.0);                                                   //INVERTIDA
    //glVertex3f (0,0,0);
     glVertex3f (nancho,-nalto,0);
    
      glTexCoord2d (0.0 , 0.0);
    //glTexCoord2d (1.0 , 0.0);                                                   // invertida
    //glVertex3f (ancho,0   ,0);
     glVertex3f (-nancho,-nalto   ,0);
     
    glTexCoord2d (0.0 , 1.0);            
 //    glTexCoord2d (1.0 ,1.0);                                                    // normal
    //glVertex3f (ancho,alto,0);
     glVertex3f (-nancho,nalto,0);
    
     glTexCoord2d (1.0 , 1.0);
//    glTexCoord2d (0.0 , 1.0);                                                   // normal
    //glVertex3f (0    ,alto,0);    
     glVertex3f (nancho    ,nalto,0);    


  glEnd();                                                                    // fin
  glDisable(GL_BLEND); 
 } /* finaliza el bucle */

}


void CLogo::termina ()
{
   /* int i;
   for (i=0;i<nsprite;i++);
    {
     textid=sprite_array[i];
     glDeleteTextures ( 1, &textid );                                           // se borran todas las texturas.
     } */
     delete [] text_array;
}   
